﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using FlexiCommerce.Components;
using FlexiCommerce.Persistence.NH;
using FlexiCommerce.Tests.Persistence.Definitions;
using NUnit.Framework;
using FlexiCommerce.Collections;
using FlexiCommerce.Details;

namespace FlexiCommerce.Tests.Persistence.NH
{
    [TestFixture]
    public class ItemQueryableTests : DatabasePreparingBase
    {
        #region SetUp

        GenericPersistenceItem rootItem;
        GenericPersistenceItem startPage;
        GenericPersistenceItem item1;
        GenericPersistenceItem item2;
        GenericPersistenceItem item3;

        [TestFixtureSetUp]
        public override void TestFixtureSetUp()
        {
            try
            {


                base.TestFixtureSetUp();

                CreateRootItem();
                CreateStartPage();
                item1 = CreatePageBelowStartPage(1);
                item2 = CreatePageBelowStartPage(2);
                item3 = CreatePageBelowStartPage(3);

            }
            catch (Exception)
            {

            }
        }

        private GenericPersistenceItem CreatePageBelowStartPage(int index)
        {
            GenericPersistenceItem item;
            item = CreateOneItem<PersistableItem2>(0, "item" + index, startPage);

            DetailCollection details = item.GetDetailCollection("DetailCollection", true);
            details.Add(true);
            details.Add(index * 1000 + 555);
            details.Add(index * 1000.0 + 555.55);
            details.Add("string in a collection " + index);
            details.Add(startPage);
            details.Add(new DateTime(2009 + index, 1, 1));

            engine.Persister.Save(item);
            return item;
        }

        [SetUp]
        public override void SetUp()
        {
            engine.Persister.Dispose();
        }

        private void CreateStartPage()
        {
            startPage = CreateOneItem<PersistableItem1>(0, "start page", rootItem);
            startPage.SortOrder = 34;
            startPage.Visible = true;
            startPage["IntDetail"] = 45;
            startPage["DoubleDetail"] = 56.66;
            startPage["BoolDetail"] = true;
            startPage["DateDetail"] = new DateTime(2000, 01, 01);
            startPage["StringDetail"] = "actually another string";
            startPage["StringDetail2"] = "just a string";
            startPage["ObjectDetail"] = new string[] { "two", "three", "four" };
            startPage["ItemDetail"] = rootItem;

            engine.Persister.Save(startPage);
        }

        private void CreateRootItem()
        {
            rootItem = CreateOneItem<PersistableItem1>(0, "root", null);
            rootItem.Created = DateTime.Today;
            rootItem.Expires = new DateTime(2017, 06, 03);
            rootItem.SortOrder = 23;
            rootItem.Visible = false;
            rootItem["IntDetail"] = 43;
            rootItem["DoubleDetail"] = 43.33;
            rootItem["BoolDetail"] = false;
            rootItem["DateDetail"] = new DateTime(1999, 12, 31);
            rootItem["StringDetail"] = "just a string";
            rootItem["StringDetail2"] = "just another string";
            rootItem["ObjectDetail"] = new string[] { "one", "two", "three" };

            engine.Persister.Save(rootItem);
        }

        #endregion

        [Test]
        public void ByPropertyID()
        {
            //GenericPersistenceItem item = Find.GenericPersistenceItem.WithID(rootItem.ID);
            
            //Assert.AreEqual(rootItem, item);
        }

        [Test]
        public void ByPropertyParent()
        {
            //IList<GenericPersistenceItem> items = Find.GenericPersistenceItem
            //    .WhichAre(GenericPersistenceItem.WithParent(rootItem))
            //    .Select();
            //Assert.AreEqual(1, items.Count);
            //Assert.AreEqual(startPage, items[0]);
        }

        [Test]
        public void ByPropertyName()
        {
            //IList<GenericPersistenceItem> items = Find.GenericPersistenceItem.WithName(rootItem.Name).ToList();
            //Assert.AreEqual(1, items.Count);
            //Assert.AreEqual(rootItem, items[0]);
        }

        [Test]
        public void ByPropertyCreated()
        {
            IList<GenericPersistenceItem> items = (from g in Find.GenericPersistenceItem where g.Created == rootItem.Created select g).ToList<GenericPersistenceItem>();
            Assert.AreEqual(1, items.Count);
            Assert.AreEqual(rootItem, items[0]);
        }

        //[Test]
        //public void ByPropertyCreatedBetween()
        //{
        //    IList<GenericPersistenceItem> items = finder
        //        .Where.Created.Between(rootItem.Created.AddMinutes(-1), rootItem.Created.AddMinutes(1))
        //        .Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void ByPropertyExpires()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Expires.Eq(rootItem.Expires.Value).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void ByPropertySortOrder()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.SortOrder.Eq(rootItem.SortOrder).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void ByPropertyVisible()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Visible.Eq(rootItem.Visible).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void ByPropertyNameAndID()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.Eq("root").And.ID.Eq(rootItem.ID).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void TwoItemsByNameOrID()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.Eq("root").Or.ID.Eq(startPage.ID).Select();
        //    Assert.AreEqual(2, items.Count);
        //    EnumerableAssert.Contains(items, rootItem);
        //    EnumerableAssert.Contains(items, startPage);
        //}

        //[Test]
        //public void ByPropertySavedBy()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.SavedBy.Eq(rootItem.SavedBy).Select();
        //    Assert.AreEqual(5, items.Count);
        //}

        //[Test]
        //public void ByPropertyType()
        //{
        //    Assert.AreEqual(3, finder.Where.Type.Eq(typeof(PersistableItem2)).Count());
        //    Assert.AreEqual(2, finder.Where.Type.Eq(typeof(PersistableItem1)).Count());
        //}

        //[Test]
        //public void IntDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("IntDetail").Eq(43).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void AnyIntDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail().Eq(43).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void DoubleDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("DoubleDetail").Eq(43.33).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void AnyDoubleDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail().Eq(43.33).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void BoolDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("BoolDetail").Eq(false).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void AnyBoolDetail()
        //{
        //    try
        //    {


        //        IList<GenericPersistenceItem> items = finder.Where.Detail().Eq(false).Select();
        //        Assert.AreEqual(1, items.Count);
        //        Assert.AreEqual(rootItem, items[0]);
        //    }
        //    catch (Exception)
        //    {

        //    }
        //}

        //[Test]
        //public void DateDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("DateDetail").Eq(new DateTime(1999, 12, 31)).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void AnyDateDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail().Eq(new DateTime(1999, 12, 31)).Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void StringDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Eq("just a string").Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void AnyStringDetail()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail().Eq("just a string").Select();
        //    Assert.AreEqual(2, items.Count);
        //    EnumerableAssert.Contains(items, rootItem);
        //    EnumerableAssert.Contains(items, startPage);
        //}

        //[Test]
        //public void DetailBetween()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where
        //        .Detail("IntDetail").Between(42, 44)
        //        .Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void AnyDetailBetween()
        //{
        //    IList<GenericPersistenceItem> items = finder
        //        .Where.Detail().Between(42, 44)
        //        .Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void StringDetailWithLike()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Like("just %").Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void AnyStringDetailWithLike()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail().Like("just %").Select();
        //    Assert.AreEqual(2, items.Count);
        //    EnumerableAssert.Contains(items, rootItem);
        //    EnumerableAssert.Contains(items, startPage);
        //}

        //[Test]
        //public void StringDetailWithLike2()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Like("% string").Select();
        //    Assert.AreEqual(2, items.Count);
        //    EnumerableAssert.Contains(items, rootItem);
        //    EnumerableAssert.Contains(items, startPage);
        //}
        //[Test]
        //public void StringDetailWithLike3()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Like("% a %").Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void DetailAndDetailWhereBothAreThere()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Eq("just a string")
        //        .And.Detail("IntDetail").Eq(43)
        //        .Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void CantFindDetailAndDetailWhenOnlyOneIsThere()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Eq("just a string")
        //        .And.Detail("StringDetail").Eq("min mollgan sträng")
        //        .Select();
        //    Assert.AreEqual(0, items.Count);
        //}

        //[Test]
        //public void CantFindPropertyAndDetailWhenOnlyPropertyIsThere()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.Eq("root")
        //        .And.Detail("StringDetail").Eq("min mollgan sträng")
        //        .Select();
        //    Assert.AreEqual(0, items.Count);
        //}

        //[Test]
        //public void CantFindPropertyAndDetailWhenOnlyDetailIsThere()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.Eq("not the root")
        //        .And.Detail("StringDetail").Eq("just a string")
        //        .Select();
        //    Assert.AreEqual(0, items.Count);
        //}

        //[Test]
        //public void PropertyOrDetailWhenOnlyPropertyIsThere()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.Eq("root")
        //        .Or.Detail("StringDetail").Eq("string that just isn't there")
        //        .Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void PropertyOrDetailWhenOnlyDetailIsThere()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.Eq("not the root")
        //        .Or.Detail("StringDetail").Eq("just a string")
        //        .Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void DetailOrDetailWhereOneIsSet()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Eq("just a string")
        //        .Or.Detail("StringDetail").Eq("string that just isn't there")
        //        .Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void DetailOrDetailWhereBothAreSet()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Eq("just a string")
        //        .Or.Detail("IntDetail").Eq(43)
        //        .Select();
        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void OnePropertyAndEitherOfTwoProperties()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.Eq("root")
        //        .And.OpenBracket()
        //            .Name.Eq("root")
        //            .Or
        //            .Name.Eq("start page")
        //        .CloseBracket()
        //        .Select();

        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void OneDetailAndEitherOfTwoProperties()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Eq("just a string")
        //        .And.OpenBracket()
        //            .Name.Eq("root")
        //            .Or
        //            .Name.Eq("start page")
        //        .CloseBracket()
        //        .Select();

        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void OnePropertyAndEitherOfTwoDetails()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.Eq("root")
        //        .And.OpenBracket()
        //            .Detail("IntDetail").Eq(45)
        //            .Or
        //            .Detail("IntDetail").Eq(43)
        //        .CloseBracket()
        //        .Select();

        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void OneDetailAndEitherOfTwoDetails()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("StringDetail").Eq("just a string")
        //        .And.OpenBracket()
        //            .Detail("IntDetail").Eq(45)
        //            .Or
        //            .Detail("IntDetail").Eq(43)
        //        .CloseBracket()
        //        .Select();

        //    Assert.AreEqual(1, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //}

        //[Test]
        //public void All()
        //{
        //    try
        //    {
        //        IList<GenericPersistenceItem> items = finder.All.Select();

        //        Assert.AreEqual(5, items.Count);
        //        EnumerableAssert.Contains(items, rootItem);
        //        EnumerableAssert.Contains(items, startPage);
        //    }
        //    catch (Exception)
        //    {

        //        throw;
        //    }

        //}

        //[Test]
        //public void OrderByPropertyAsc()
        //{
        //    IList<GenericPersistenceItem> items = finder.All.OrderBy.Name.Asc.Select();

        //    Assert.AreEqual(5, items.Count);
        //    Assert.AreEqual(rootItem, items[3]);
        //    Assert.AreEqual(startPage, items[4]);
        //}

        //[Test]
        //public void OrderByPropertyDesc()
        //{
        //    IList<GenericPersistenceItem> items = finder.All.OrderBy.Name.Desc.Select();

        //    Assert.AreEqual(5, items.Count);
        //    Assert.AreEqual(startPage, items[0]);
        //    Assert.AreEqual(rootItem, items[1]);
        //}

        //[Test]
        //public void WithCountFilter()
        //{
        //    IList<GenericPersistenceItem> items = finder.All
        //        .Filters(new CountFilter(0, 2))
        //        .OrderBy.ID.Asc.Select();

        //    Assert.AreEqual(2, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //    Assert.AreEqual(startPage, items[1]);
        //}

        //[Test]
        //public void FindWithFilterEnumeration()
        //{
        //    IList<ItemFilter> filters = new List<ItemFilter>();
        //    filters.Add(new ParentFilter((IHierarchalPersistenceItem)startPage));
        //    filters.Add(new CountFilter(0, 2));
        //    IList<GenericPersistenceItem> items = finder.All
        //        .Filters(filters)
        //        .OrderBy.ID.Asc.Select();

        //    Assert.AreEqual(2, items.Count);
        //    Assert.AreEqual(item1, items[0]);
        //    Assert.AreEqual(item2, items[1]);
        //}

        //[Test]
        //public void OrderByDetailDesc()
        //{
        //    IList<GenericPersistenceItem> items = finder.All.OrderBy.Detail("IntDetail").Desc.Select();

        //    Assert.AreEqual(5, items.Count);
        //    Assert.AreEqual(startPage, items[0]);
        //    Assert.AreEqual(rootItem, items[1]);

        //}

        //[Test]
        //public void FilterCount()
        //{
        //    IList<GenericPersistenceItem> items = finder.All.OrderBy.Detail("IntDetail").Desc.Select();

        //    Assert.AreEqual(5, items.Count);
        //    Assert.AreEqual(startPage, items[0]);
        //    Assert.AreEqual(rootItem, items[1]);
        //}

        //[Test]
        //public void BoolInDetailCollection()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("DetailCollection").Eq(true).Select();
        //    Assert.AreEqual(3, items.Count);
        //}

        //[Test]
        //public void IntInDetailCollection()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("DetailCollection").Gt(2000).Select();
        //    Assert.AreEqual(2, items.Count);
        //}

        //[Test]
        //public void StringInDetailCollection()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("DetailCollection").Like("string in a collection %").Select();
        //    Assert.AreEqual(3, items.Count);
        //}

        //[Test]
        //public void LinkInDetailCollection()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("DetailCollection").Eq(startPage).Select();
        //    Assert.AreEqual(3, items.Count);
        //}

        //[Test]
        //public void DateInDetailCollection()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail("DetailCollection").Le(new DateTime(2011, 1, 1)).Select();
        //    Assert.AreEqual(2, items.Count);
        //}

        //[Test]
        //public void AllWithFirstResult()
        //{
        //    IList<GenericPersistenceItem> items = finder.All.FirstResult(3).OrderBy.ID.Desc.Select();
        //    Assert.AreEqual(2, items.Count);
        //    Assert.AreEqual(startPage, items[0]);
        //    Assert.AreEqual(rootItem, items[1]);
        //}

        //[Test]
        //public void AllWithMaxResults()
        //{
        //    IList<GenericPersistenceItem> items = finder.All.MaxResults(2).OrderBy.ID.Asc.Select();
        //    Assert.AreEqual(2, items.Count);
        //    Assert.AreEqual(rootItem, items[0]);
        //    Assert.AreEqual(startPage, items[1]);
        //}

        //[Test]
        //public void AllWithFirstAndMaxResults()
        //{
        //    IList<GenericPersistenceItem> items = finder.All.FirstResult(2).MaxResults(2).OrderBy.ID.Asc.Select();
        //    Assert.AreEqual(2, items.Count);
        //    Assert.AreEqual(item1, items[0]);
        //    Assert.AreEqual(item2, items[1]);
        //}

        //[Test]
        //public void FilterByTypeEqual()
        //{
        //    IList<PersistableItem2> items = finder.Where.Type.Eq(typeof(PersistableItem2)).Select<PersistableItem2>();
        //    Assert.AreEqual(3, items.Count);
        //    EnumerableAssert.Contains(items, item1);
        //    EnumerableAssert.Contains(items, item2);
        //    EnumerableAssert.Contains(items, item3);
        //}

        //[Test]
        //public void FilterByTypeEqual2()
        //{
        //    IList<PersistableItem1> items = finder.Where.Type.Eq(typeof(PersistableItem1)).Select<PersistableItem1>();
        //    Assert.AreEqual(2, items.Count);
        //    EnumerableAssert.Contains(items, rootItem);
        //    EnumerableAssert.Contains(items, startPage);
        //}

        //[Test]
        //public void FilterByTypeNotEqual()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Type.NotEq(typeof(PersistableItem2)).Select();
        //    Assert.AreEqual(2, items.Count);
        //    EnumerableAssert.Contains(items, rootItem);
        //    EnumerableAssert.Contains(items, startPage);
        //}

        //[Test]
        //public void ByPropertyIsNull()
        //{
        //    //TODO: IsNULL
        //    //Assert.AreEqual(rootItem, finder.Where.Parent.IsNull().Select()[0]);
        //}

        //[Test]
        //public void FilterByTypeAndName()
        //{
        //    IList<PersistableItem2> items = finder
        //        .Where.Type.Eq(typeof(PersistableItem2))
        //        .And.Name.Eq("item1")
        //        .Select<PersistableItem2>();
        //    Assert.AreEqual(1, items.Count);
        //    EnumerableAssert.Contains(items, item1);
        //}

        //[Test]
        //public void CanCountByTypeEqual()
        //{
        //    int count = finder.Where.Type.Eq(typeof(PersistableItem2)).Count();
        //    Assert.AreEqual(3, count);
        //}

        //[Test]
        //public void CanCountAll()
        //{
        //    int count = finder.All.Count();
        //    Assert.AreEqual(5, count);
        //}

        //[Test]
        //public void CanCountByPropertyName()
        //{
        //    int count = finder.Where.Name.Eq(rootItem.Name).Count();
        //    Assert.AreEqual(1, count);
        //}

        //[Test]
        //public void CanCountAnyStringDetail()
        //{
        //    int count = finder.Where.Detail().Eq("just a string").Count();
        //    Assert.AreEqual(2, count);
        //}

        //[Test]
        //public void CanSelectByPropertyNameIn()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Name.In(rootItem.Name, startPage.Name).Select();
        //    Assert.AreEqual(2, items.Count);
        //    EnumerableAssert.Contains(items, rootItem);
        //    EnumerableAssert.Contains(items, startPage);
        //}

        //[Test]
        //public void CanSelectByDetailIn()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Detail().In(43, 45).Select();
        //    Assert.AreEqual(2, items.Count);
        //    EnumerableAssert.Contains(items, rootItem);
        //    EnumerableAssert.Contains(items, startPage);
        //}

        //[Test]
        //public void CanSelectByClassIn()
        //{
        //    IList<GenericPersistenceItem> items = finder.Where.Type.In(typeof(PersistableItem2), typeof(PersistableItem1)).Select();
        //    Assert.AreEqual(5, items.Count);
        //}
    }
}
